function isDebug()
    return false
end

function math.round( num )
    -- body
    return math.floor(num + 0.5)
end

function math.clip( min, max, v )
    -- body
    if     max < min then
        min, max = max, min
    end

    if v < min then
        return min
    end

    if max < v then
        return max
    end

    return v
end

function table.find_if( t, pred )
    -- body
    for k, v in pairs(t) do
        if pred(v) then
            return v
        end
    end
end

function table.count( t )
    -- body
    local sum = 0
    for k, v in pairs(t) do
        sum = sum + 1
    end
    return sum
end



function nullFunc()

end

function toBool( v )
    return not not v
end

function randomFromTable( t )
    local count = table.count(t)
    if count == 0 then
        return
    end
    local idx = math.random(count)

    local i = 0
    for k,v in pairs(t) do
        i = i + 1
        if idx == i then
            return k
        end
    end
end


local function clone(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object 
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for key, value in pairs(object) do
            new_table[_copy(key)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end
    return _copy(object)
end


--[[
Base = LUA_CLASS('Base')

function Base:ctor()
    self.idx = 1
    print('function Base:ctor()')
end

function Base:g()
    print('function Base:g()')
end

------------

Child = CLASS(Base)
function Child:ctor()
    --self.super.ctor(self)
    print('function Child:ctor()')
    --self:test()
end

function Child:g() 
    print('function Child:g()')
    
end

local child = Child.new()
]]


local function privateCtor( instance, cls, ... )
    -- body
    if type(cls) == 'table' then
        privateCtor(instance, cls.super, ...)
        cls.ctor(instance, ...)
    end
end

function CLASS( super )
    -- body
    local superType = type(super)
    local cls

    if superType ~= "function" and superType ~= "table" then
        superType = nil
        super = nil
    end

    if superType == "function" or (super and super.__ctype == 1) then
        -- inherited from native C++ Object
        cls = {}

        if superType == "table" then
            -- copy fields from super
            for k,v in pairs(super) do cls[k] = v end
            cls.__create = super.__create
            cls.super    = super
        else
            cls.__create = super
        end

        cls.ctor    = function() end
        cls.__ctype = 1



        function cls.new(...)
            local instance = cls.__create(...)
            -- copy fields from class to native object
            for k,v in pairs(cls) do 
                instance[k] = v 
            end
            instance.class = cls
            --instance:ctor(...)
            privateCtor(instance, cls,...)
            return instance
        end

    else
          -- inherited from Lua Object
        if super then
            cls = clone(super)
            cls.super = super
        else
            cls = {}
        end

        cls.ctor = function() end

        cls.__ctype = 2 -- lua
        cls.__index = cls

        function cls.new(...)
            local instance = setmetatable({}, cls)
            instance.class = cls
            --instance:ctor(...)
            privateCtor(instance, cls,...)
            return instance
        end
    end

    return cls
end



print('GlobalFunc.lua load ...')